package com.campus.help.controller;

import com.baomidou.mybatisplus.core.metadata.IPage;
import com.campus.help.common.Result;
import com.campus.help.entity.LaborType;
import com.campus.help.service.LaborTypeService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import javax.validation.Valid;
import javax.validation.constraints.Min;
import javax.validation.constraints.NotEmpty;
import javax.validation.constraints.NotNull;
import java.util.List;

/**
 * 劳务类型管理控制器
 *
 * @author campus-help
 * @since 2025-09-18
 */
@Slf4j
@RestController
@RequestMapping("/labor-types")
@Validated
public class LaborTypeController {

    @Autowired
    private LaborTypeService laborTypeService;

    /**
     * 分页查询劳务类型（管理员）
     */
    @GetMapping("/page")
    public Result<IPage<LaborType>> getLaborTypePage(
            @RequestParam(defaultValue = "1") @Min(1) Integer page,
            @RequestParam(defaultValue = "10") @Min(1) Integer size,
            @RequestParam(required = false) String typeName,
            @RequestParam(required = false) Integer status) {

        try {
            log.info("分页查询劳务类型，页码：{}，大小：{}，类型名称：{}，状态：{}", page, size, typeName, status);

            IPage<LaborType> result = laborTypeService.getLaborTypePage(page, size, typeName, status);

            return Result.success(result);
        } catch (Exception e) {
            log.error("分页查询劳务类型失败", e);
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 获取启用状态的劳务类型列表（公开接口）
     */
    @GetMapping("/enabled")
    public Result<List<LaborType>> getEnabledTypes() {
        try {
            log.info("获取启用状态的劳务类型列表");

            List<LaborType> types = laborTypeService.getEnabledTypes();

            return Result.success(types);
        } catch (Exception e) {
            log.error("获取启用类型列表失败", e);
            return Result.error("获取失败：" + e.getMessage());
        }
    }

    /**
     * 根据ID查询劳务类型详情
     */
    @GetMapping("/{id}")
    public Result<LaborType> getLaborTypeById(@PathVariable @NotNull Long id) {

        try {
            log.info("查询劳务类型详情，ID：{}", id);

            LaborType laborType = laborTypeService.getById(id);
            if (laborType == null) {
                return Result.error("劳务类型不存在");
            }

            return Result.success(laborType);
        } catch (Exception e) {
            log.error("查询劳务类型详情失败", e);
            return Result.error("查询失败：" + e.getMessage());
        }
    }

    /**
     * 创建劳务类型（管理员）
     */
    @PostMapping
    public Result<LaborType> createLaborType(@Valid @RequestBody LaborType laborType) {
        try {
            log.info("创建劳务类型：{}", laborType.getTypeName());

            LaborType result = laborTypeService.createLaborType(laborType);

            return Result.success(result);
        } catch (Exception e) {
            log.error("创建劳务类型失败", e);
            return Result.error("创建失败：" + e.getMessage());
        }
    }

    /**
     * 更新劳务类型（管理员）
     */
    @PutMapping("/{id}")
    public Result<LaborType> updateLaborType(
            @PathVariable @NotNull Long id,
            @Valid @RequestBody LaborType laborType) {

        try {
            log.info("更新劳务类型，ID：{}", id);

            laborType.setId(id);
            LaborType result = laborTypeService.updateLaborType(laborType);

            return Result.success(result);
        } catch (Exception e) {
            log.error("更新劳务类型失败", e);
            return Result.error("更新失败：" + e.getMessage());
        }
    }

    /**
     * 删除劳务类型（管理员）
     */
    @DeleteMapping("/{id}")
    public Result<Void> deleteLaborType(@PathVariable @NotNull Long id) {
        try {
            log.info("删除劳务类型，ID：{}", id);
            boolean result = laborTypeService.deleteLaborType(id);

            return result ? Result.success() : Result.error("删除失败");
        } catch (Exception e) {
            log.error("删除劳务类型失败", e);
            return Result.error("删除失败：" + e.getMessage());
        }
    }

    /**
     * 批量删除劳务类型（管理员）
     */
    @DeleteMapping("/batch")
    public Result<Void> batchDeleteLaborTypes(@RequestBody @NotEmpty List<Long> typeIds) {

        try {
            log.info("批量删除劳务类型，数量：{}", typeIds.size());

            boolean result = laborTypeService.batchDeleteLaborTypes(typeIds);

            return result ? Result.success() : Result.error("批量删除失败");
        } catch (Exception e) {
            log.error("批量删除劳务类型失败", e);
            return Result.error("批量删除失败：" + e.getMessage());
        }
    }

    /**
     * 更新劳务类型状态（管理员）
     */
    @PutMapping("/{id}/status")
    public Result<Void> updateStatus(
            @PathVariable @NotNull Long id,
            @RequestParam @NotNull Integer status) {

        try {
            log.info("更新劳务类型状态，ID：{}，状态：{}", id, status);

            boolean result = laborTypeService.updateStatus(id, status);

            return result ? Result.success() : Result.error("状态更新失败");
        } catch (Exception e) {
            log.error("更新劳务类型状态失败", e);
            return Result.error("状态更新失败：" + e.getMessage());
        }
    }

    /**
     * 更新劳务类型排序（管理员）
     */
    @PutMapping("/{id}/sort")
    public Result<Void> updateSortOrder(
            @PathVariable @NotNull Long id,
            @RequestParam @NotNull @Min(1) Integer sortOrder) {

        try {
            log.info("更新劳务类型排序，ID：{}，排序值：{}", id, sortOrder);

            boolean result = laborTypeService.updateSortOrder(id, sortOrder);

            return result ? Result.success() : Result.error("排序更新失败");
        } catch (Exception e) {
            log.error("更新劳务类型排序失败", e);
            return Result.error("排序更新失败：" + e.getMessage());
        }
    }

    /**
     * 批量更新劳务类型排序（管理员）
     */
    @PutMapping("/batch-sort")
    public Result<Void> batchUpdateSortOrder(@RequestBody @NotEmpty List<Long> typeIds) {

        try {
            log.info("批量更新劳务类型排序，数量：{}", typeIds.size());

            boolean result = laborTypeService.batchUpdateSortOrder(typeIds);

            return result ? Result.success() : Result.error("批量排序更新失败");
        } catch (Exception e) {
            log.error("批量更新劳务类型排序失败", e);
            return Result.error("批量排序更新失败：" + e.getMessage());
        }
    }

    /**
     * 获取系统默认类型列表（管理员）
     */
    @GetMapping("/defaults")
    public Result<List<LaborType>> getDefaultTypes() {
        try {
            log.info("获取系统默认类型列表");

            List<LaborType> types = laborTypeService.getDefaultTypes();

            return Result.success(types);
        } catch (Exception e) {
            log.error("获取系统默认类型列表失败", e);
            return Result.error("获取失败：" + e.getMessage());
        }
    }

    /**
     * 检查类型名称是否存在（管理员）
     */
    @GetMapping("/check-name")
    public Result<Boolean> checkTypeNameExists(@RequestParam @NotEmpty String typeName, @RequestParam(required = false) Long excludeId) {

        try {
            log.info("检查类型名称是否存在：{}，排除ID：{}", typeName, excludeId);

            boolean exists = laborTypeService.checkTypeNameExists(typeName, excludeId);

            return Result.success(exists);
        } catch (Exception e) {
            log.error("检查类型名称失败", e);
            return Result.error("检查失败：" + e.getMessage());
        }
    }

    /**
     * 获取类型使用统计（管理员）
     */
    @GetMapping("/{id}/usage-count")
    public Result<Long> getTypeUsageCount(@PathVariable @NotNull Long id) {

        try {
            log.info("获取类型使用统计，ID：{}", id);

            Long count = laborTypeService.getTypeUsageCount(id);

            return Result.success(count);
        } catch (Exception e) {
            log.error("获取类型使用统计失败", e);
            return Result.error("获取失败：" + e.getMessage());
        }
    }
}



